package com.cqeec.gams.service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.cqeec.gams.common.Function;
import com.cqeec.gams.dao.FunctionalModuleMapper;
import com.cqeec.gams.dao.RolePermissionsMapper;
import com.cqeec.gams.entity.FunctionalModule;

/**
 * 功能模块服务。
 * 
 * @author 唐礼飞
 *
 */
@Service
public class FunctionalModuleServiceImpl implements FunctionalModuleService {
	@Autowired
	private FunctionalModuleMapper fmMapper;
	@Autowired
	private RolePermissionsMapper rpMapper;

	@Override
	public long count() {
		return fmMapper.count();
	}

	@Override
	public FunctionalModule findById(String id) {
		return fmMapper.findById(id);
	}

	@Override
	public List<FunctionalModule> findAll() {
		return fmMapper.findAll();
	}

	@Override
	public List<FunctionalModule> findPage(int startRowNumber, int pageSize) {
		return fmMapper.findPage(startRowNumber, pageSize);
	}

	@Override
	public void insert(FunctionalModule entity) {
		fmMapper.insert(entity);
	}

	@Override
	public void update(FunctionalModule entity) {
		fmMapper.update(entity);
	}

	@Override
	public void delete(String id) {
		fmMapper.delete(id);
	}

	@Override
	public List<FunctionalModule> getAllFunctionGroup() {
		return fmMapper.findAllFunctionGroup();
	}

	@Override
	public Map<String, Object> deleteFunciton(String id) {
		Map<String, Object> map = new HashMap<>();
		FunctionalModule function = fmMapper.findById(id);
		String type = function.getType();
		// 查询功能有没有授权给角色
		int total = rpMapper.countRolePermissions(id);
		if (total != 0) {
			// 表示功能有角色授权，不能删除
			map.put("code", 1);
			map.put("message", "功能有角色授权，不能删除!");
			return map;
		}
		if ("1".equals(type)) {
			// 删除的是功能组
			total = fmMapper.countSubFunction(id);
			if (total == 0) {
				fmMapper.delete(id);
				map.put("code", 0);
				map.put("message", "删除功能成功!");
				return map;
			} else {
				// 表示此功能是功能组且下面有功能模块，不能删除
				map.put("code", 2);
				map.put("message", "功能是功能组，功能组中有功能模块，不能删除!");
				return map;
			}
		}
		// 删除的是功能模块
		try {
			fmMapper.delete(id);
			map.put("code", 0);
			map.put("message", "删除功能成功!");
		} catch (Exception e) {
			e.printStackTrace();
			map.put("code", 0);
			map.put("message", "删除功能失败!");
		}
		return map;
	}

	@Override
	public List<Function> getAllFunction() {
		List<Function> functions = new ArrayList<>();
		List<FunctionalModule> list = fmMapper.findAll();
		// 查找功能组
		String type;
		Function fun;
		List<FunctionalModule> tempList = new ArrayList<>();
		for (FunctionalModule fm : list) {
			type = fm.getType();
			if ("1".equals(type)) {
				fun = new Function();
				fun.setFunctionGroup(fm);
				functions.add(fun);
				tempList.add(fm); // 将功能组添加到临时列表中，以便后面从所有功能列表中清除
			}
		}
		list.removeAll(tempList); // 从所有功能模块中移除功能级，剩下的就是功能模块
		tempList.clear(); // 将临时列表中的所有元素清除
		// 将功能模块封装到相应的功能组中
		String parentId, functionGorupId;
		FunctionalModule fg;
		// 循环功能组
		for (Function f : functions) {
			fg = f.getFunctionGroup();
			functionGorupId = fg.getId();
			// 循环功能模块，将功能模块加入功能组中
			for (FunctionalModule fm : list) {
				parentId = fm.getParent();
				if (parentId.equals(functionGorupId)) {
					f.addFunctionModule(fm);
					tempList.add(fm);
				}
			}
			list.removeAll(tempList);
			tempList.clear();
		}
		// 返回封装好的功能
		return functions;
	}

}
